home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / CLOBSH.PAK / STACK.H < prev    next >
C/C++ Source or Header  |  1997-05-06  |  16KB  |  607 lines
  1. /*------------------------------------------------------------------------*/
  2. /*                                                                        */
  3. /*  STACK.H                                                               */
  4. /*                                                                        */
  5. /*  Copyright Borland International 1991, 1993                            */
  6. /*  All Rights Reserved                                                   */
  7. /*                                                                        */
  8. /*------------------------------------------------------------------------*/
  9.  
  10. #if !defined( __STACK_H )
  11. #define __STACK_H
  12.  
  13. #define BI_OLDNAMES
  14.  
  15. #if !defined( TEMPLATES )
  16.  
  17. #if !defined( __CLSTYPES_H )
  18. #include "classlib\obsolete\ClsTypes.h"
  19. #endif  // __CLSTYPES_H
  20.  
  21. #if !defined( __CONTAIN_H )
  22. #include "classlib\obsolete\Contain.h"
  23. #endif  // __CONTAIN_H
  24.  
  25. #if !defined( __LIST_H )
  26. #include "classlib\obsolete\List.h"
  27. #endif  // __LIST_H
  28.  
  29. #pragma option -Vo-
  30. #if defined( __BCOPT__ ) && !defined( __FLAT__ ) && !defined( _ALLOW_po )
  31. #pragma option -po-
  32. #endif
  33.  
  34. _CLASSDEF(Stack)
  35.  
  36. class _CLASSTYPE Stack : public Container
  37. {
  38.  
  39. public:
  40.  
  41.     void push( Object _FAR & );
  42.     Object _FAR & pop();
  43.     Object _FAR & top() const
  44.         {
  45.         return list.peekHead();
  46.         }
  47.  
  48.     virtual void flush( DeleteType dt = DefDelete )
  49.         {
  50.         list.flush( dt );
  51.         }
  52.  
  53.     virtual int isEmpty() const
  54.         {
  55.         return list.isEmpty();
  56.         }
  57.  
  58.     virtual countType getItemsInContainer() const
  59.         {
  60.         return list.getItemsInContainer();
  61.         }
  62.  
  63.     virtual void forEach( iterFuncType f, void _FAR *arg )
  64.         {
  65.         list.forEach( f, arg );
  66.         }
  67.  
  68.     virtual Object _FAR & firstThat( condFuncType f, void _FAR *arg ) const
  69.         {
  70.         return list.firstThat( f, arg );
  71.         }
  72.  
  73.     virtual Object _FAR & lastThat( condFuncType f, void _FAR *arg ) const
  74.         {
  75.         return list.lastThat( f, arg );
  76.         }
  77.  
  78.     virtual classType isA() const
  79.         {
  80.         return stackClass;
  81.         }
  82.  
  83.     virtual _TCHAR _FAR *nameOf() const
  84.         {
  85.         return "Stack";
  86.         }
  87.  
  88.     virtual hashValueType hashValue() const
  89.         {
  90.         return list.hashValue();
  91.         }
  92.  
  93.     virtual int isEqual( const Object& obj ) const
  94.         {
  95.         return list.isEqual( obj );
  96.         }
  97.  
  98.     virtual int isSortable() const
  99.         {
  100.         return list.isSortable();
  101.         }
  102.  
  103.     virtual int isAssociation() const
  104.         {
  105.         return list.isAssociation();
  106.         }
  107.  
  108.     virtual void printOn( ostream& os ) const
  109.         {
  110.         list.printOn( os );
  111.         }
  112.  
  113.     virtual void printHeader( ostream& os ) const
  114.         {
  115.         list.printHeader( os );
  116.         }
  117.  
  118.     virtual void printSeparator( ostream& os ) const
  119.         {
  120.         list.printSeparator( os );
  121.         }
  122.  
  123.     virtual void printTrailer( ostream& os ) const
  124.         {
  125.         list.printTrailer( os );
  126.         }
  127.  
  128.     virtual ContainerIterator _FAR & initIterator() const;
  129.  
  130.     int ownsElements()
  131.         {
  132.         return list.ownsElements();
  133.         }
  134.  
  135.     void ownsElements( int del )
  136.         { 
  137.         list.ownsElements( del );
  138.         }
  139.  
  140. private:
  141.  
  142.     List list;
  143.  
  144. };
  145.  
  146. #else   // TEMPLATES
  147.  
  148. #if !defined( __CONTAIN_H )
  149. #include "classlib\obsolete\Contain.h"
  150. #endif  // __CONTAIN_H
  151.  
  152. #if !defined( __STACKS_H )
  153. #include "classlib\Stacks.h"
  154. #endif  // __STACKS_H
  155.  
  156. #pragma option -Vo-
  157. #if defined( __BCOPT__ ) && !defined( __FLAT__ ) && !defined( _ALLOW_po )
  158. #pragma option -po-
  159. #endif
  160.  
  161. #define Stack   BI_TCStackAsList
  162. #define PStack  PBI_TCStackAsList
  163. #define RStack  RBI_TCStackAsList
  164. #define RPStack RPBI_TCStackAsList
  165. #define PCStack PCBI_TCStackAsList
  166. #define RCStack RCBI_TCStackAsList
  167.  
  168. _CLASSDEF( BI_TCStackAsList )
  169.  
  170. #define StackIterator   BI_TCStackAsListIterator
  171. #define PStackIterator  PBI_TCStackAsListIterator
  172. #define RStackIterator  RBI_TCStackAsListIterator
  173. #define RPStackIterator RPBI_TCStackAsListIterator
  174. #define PCStackIterator PCBI_TCStackAsListIterator
  175. #define RCStackIterator RCBI_TCStackAsListIterator
  176.  
  177. _CLASSDEF( BI_TCStackAsListIterator )
  178.  
  179. /*------------------------------------------------------------------------*/
  180. /*                                                                        */
  181. /*  class BI_OStackAsVector                                               */
  182. /*                                                                        */
  183. /*  Implements a stack of pointers to Object,                             */
  184. /*  using a vector as the underlying implementation.                      */
  185. /*                                                                        */
  186. /*------------------------------------------------------------------------*/
  187.  
  188. class _CLASSTYPE BI_OStackAsVector : private BI_IStackAsVector<Object>
  189. {
  190.  
  191. public:
  192.  
  193.     friend class _CLASSTYPE BI_OStackAsVectorIterator;
  194.  
  195.     BI_OStackAsVector( unsigned max = DEFAULT_STACK_SIZE ) :
  196.         BI_IStackAsVector<Object>( max )
  197.         {
  198.         }
  199.  
  200.  
  201.     void push( Object _FAR *t )
  202.         {
  203.         BI_IStackAsVector<Object>::push( t );
  204.         }
  205.  
  206.     Object _FAR *pop()
  207.         {
  208.         return (Object _FAR *)(BI_IStackAsVector<Object>::pop());
  209.         }
  210.  
  211.     Object _FAR *top() const
  212.         {
  213.         return (Object _FAR *)(BI_IStackAsVector<Object>::top());
  214.         }
  215.  
  216.     int isEmpty() const
  217.         {
  218.         return BI_IStackAsVector<Object>::isEmpty();
  219.         }
  220.  
  221.     int isFull() const
  222.         {
  223.         return BI_IStackAsVector<Object>::isFull();
  224.         }
  225.  
  226.     void forEach( iterFuncType f, void _FAR*args )
  227.         {
  228.         BI_IStackAsVector<Object>::forEach( f, args );
  229.         }
  230.  
  231.     Object _FAR *firstThat( condFuncType f, void _FAR *args ) const
  232.         {
  233.         return BI_IStackAsVector<Object>::firstThat( f, args );
  234.         }
  235.  
  236.     Object _FAR *lastThat( condFuncType f, void _FAR *args ) const
  237.         {
  238.         return BI_IStackAsVector<Object>::lastThat( f, args );
  239.         }
  240.  
  241.     void flush( TShouldDelete::DeleteType dt )
  242.         {
  243.         BI_IStackAsVector<Object>::flush( dt );
  244.         }
  245.  
  246.     int getItemsInContainer() const
  247.         {
  248.         return BI_IStackAsVector<Object>::getItemsInContainer();
  249.         }
  250.  
  251. };
  252.  
  253. class _CLASSTYPE BI_OStackAsVectorIterator :
  254.     public BI_IStackAsVectorIterator<Object>
  255. {
  256.  
  257. public:
  258.  
  259.     BI_OStackAsVectorIterator( const BI_OStackAsVector _FAR & s ) :
  260.         BI_IStackAsVectorIterator<Object>((const BI_IStackAsVector<Object>&)s)
  261.         {
  262.         }
  263.  
  264. };
  265.  
  266. /*------------------------------------------------------------------------*/
  267. /*                                                                        */
  268. /*  class BI_TCStackAsVector                                              */
  269. /*                                                                        */
  270. /*  Implements an Object stack, with the full semantics of                */
  271. /*  the BC 2.0 style stack, using a vector as the underlying              */
  272. /*  implementation.                                                       */
  273. /*                                                                        */
  274. /*------------------------------------------------------------------------*/
  275.  
  276. class _CLASSTYPE BI_TCStackAsVector : 
  277.     public Container, 
  278.     private BI_OStackAsVector
  279. {
  280.  
  281. public:
  282.  
  283.     friend class _CLASSTYPE BI_TCStackAsVectorIterator;
  284.  
  285.     BI_TCStackAsVector( unsigned lim = DEFAULT_STACK_SIZE ) :
  286.         BI_OStackAsVector(lim)
  287.         {
  288.         }
  289.  
  290.     void push( Object _FAR & o )
  291.         {
  292.         BI_OStackAsVector::push( &o );
  293.         }
  294.  
  295.     Object _FAR & pop()
  296.         {
  297.         return ptrToRef(BI_OStackAsVector::pop());
  298.         }
  299.  
  300.     Object _FAR & top() const
  301.         {
  302.         return ptrToRef(BI_OStackAsVector::top());
  303.         }
  304.  
  305.     virtual int isEmpty() const
  306.         {
  307.         return BI_OStackAsVector::isEmpty();
  308.         }
  309.  
  310.     virtual countType getItemsInContainer() const
  311.         {
  312.         return BI_OStackAsVector::getItemsInContainer();
  313.         }
  314.  
  315.     virtual void flush( DeleteType dt = DefDelete )
  316.         {
  317.         BI_OStackAsVector::flush( dt );
  318.         }
  319.  
  320.     virtual ContainerIterator _FAR & initIterator() const;
  321.  
  322.     virtual classType isA() const
  323.         {
  324.         return stackClass;
  325.         }
  326.  
  327.     virtual _TCHAR _FAR *nameOf() const
  328.         {
  329.         return "BI_TCStackAsVector";
  330.         }
  331.  
  332.     virtual void forEach( iterFuncType f, void _FAR *args )
  333.         {
  334.         BI_OStackAsVector::forEach( f, args );
  335.         }
  336.  
  337.     virtual Object _FAR & firstThat( condFuncType f, void _FAR *args ) const
  338.         {
  339.         return ptrToRef(BI_OStackAsVector::firstThat( f, args ));
  340.         }
  341.  
  342.     virtual Object _FAR & lastThat( condFuncType f, void _FAR *args ) const
  343.         {
  344.         return ptrToRef(BI_OStackAsVector::lastThat( f, args ));
  345.         }
  346.  
  347. };
  348.  
  349. class _CLASSTYPE BI_TCStackAsVectorIterator : public ContainerIterator
  350. {
  351.  
  352. public:
  353.  
  354.     BI_TCStackAsVectorIterator( const BI_TCStackAsVector _FAR & s ) :
  355.         iter((const BI_OStackAsVector&)s)
  356.         {
  357.         }
  358.  
  359.     virtual operator int()
  360.         {
  361.         return int(iter);
  362.         }
  363.  
  364.     virtual Object _FAR & current()
  365.         {
  366.         return Object::ptrToRef(iter.current());
  367.         }
  368.  
  369.     virtual Object _FAR & operator ++ ( int )
  370.         {
  371.         return Object::ptrToRef(iter++);
  372.         }
  373.  
  374.     virtual Object _FAR & operator ++ ()
  375.         {
  376.         return Object::ptrToRef(++iter);
  377.         }
  378.  
  379.     virtual void restart()
  380.         {
  381.         iter.restart();
  382.         }
  383.  
  384. private:
  385.  
  386.     BI_OStackAsVectorIterator iter;
  387.  
  388. };
  389.  
  390. inline ContainerIterator _FAR & BI_TCStackAsVector::initIterator() const
  391. {
  392.     return *new BI_TCStackAsVectorIterator( *this );
  393. }
  394.  
  395. /*------------------------------------------------------------------------*/
  396. /*                                                                        */
  397. /*  class BI_OStackAsList                                                 */
  398. /*                                                                        */
  399. /*  Implements a stack of pointers to Object,                             */
  400. /*  using a list as the underlying implementation.                        */
  401. /*                                                                        */
  402. /*------------------------------------------------------------------------*/
  403.  
  404. class _CLASSTYPE BI_OStackAsList : private BI_IStackAsList<Object>
  405. {
  406.  
  407. public:
  408.  
  409.     friend class _CLASSTYPE BI_OStackAsListIterator;
  410.  
  411.     void push( Object _FAR *t )
  412.         {
  413.         BI_IStackAsList<Object>::push( t );
  414.         }
  415.  
  416.     Object _FAR *pop()
  417.         {
  418.         return (Object _FAR *)(BI_IStackAsList<Object>::pop());
  419.         }
  420.  
  421.     Object _FAR *top() const
  422.         {
  423.         return (Object _FAR *)(BI_IStackAsList<Object>::top());
  424.         }
  425.  
  426.     int isEmpty() const
  427.         {
  428.         return BI_IStackAsList<Object>::isEmpty();
  429.         }
  430.  
  431.     int isFull() const
  432.         {
  433.         return BI_IStackAsList<Object>::isFull();
  434.         }
  435.  
  436.     void forEach( iterFuncType f, void _FAR*args )
  437.         {
  438.         BI_IStackAsList<Object>::forEach( f, args );
  439.         }
  440.  
  441.     Object _FAR *firstThat( condFuncType f, void _FAR *args ) const
  442.         {
  443.         return BI_IStackAsList<Object>::firstThat( f, args );
  444.         }
  445.  
  446.     Object _FAR *lastThat( condFuncType f, void _FAR *args ) const
  447.         {
  448.         return BI_IStackAsList<Object>::lastThat( f, args );
  449.         }
  450.  
  451.     void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
  452.         {
  453.         BI_IStackAsList<Object>::flush( dt );
  454.         }
  455.  
  456.     int getItemsInContainer() const
  457.         {
  458.         return BI_IStackAsList<Object>::getItemsInContainer();
  459.         }
  460.  
  461. };
  462.  
  463. class _CLASSTYPE BI_OStackAsListIterator :
  464.     public BI_IStackAsListIterator<Object>
  465. {
  466.  
  467. public:
  468.  
  469.     BI_OStackAsListIterator( const BI_OStackAsList _FAR & s ) :
  470.         BI_IStackAsListIterator<Object>((const BI_IStackAsList<Object>&)s)
  471.         {
  472.         }
  473.  
  474. };
  475.  
  476. /*------------------------------------------------------------------------*/
  477. /*                                                                        */
  478. /*  class BI_TCStackAsList                                                */
  479. /*                                                                        */
  480. /*  Implements an Object stack, with the full semantics of                */
  481. /*  the BC 2.0 style stack, using a list as the underlying                */
  482. /*  implementation.                                                       */
  483. /*                                                                        */
  484. /*------------------------------------------------------------------------*/
  485.  
  486. class _CLASSTYPE BI_TCStackAsList : public Container, private BI_OStackAsList
  487. {
  488.  
  489. public:
  490.  
  491.     friend class _CLASSTYPE BI_TCStackAsListIterator;
  492.  
  493.     void push( Object _FAR & o )
  494.         {
  495.         BI_OStackAsList::push( &o );
  496.         }
  497.  
  498.     Object _FAR & pop()
  499.         {
  500.         return ptrToRef(BI_OStackAsList::pop());
  501.         }
  502.  
  503.     Object _FAR & top() const
  504.         {
  505.         return ptrToRef(BI_OStackAsList::top());
  506.         }
  507.  
  508.     virtual int isEmpty() const
  509.         {
  510.         return BI_OStackAsList::isEmpty();
  511.         }
  512.  
  513.     virtual countType getItemsInContainer() const
  514.         {
  515.         return BI_OStackAsList::getItemsInContainer();
  516.         }
  517.  
  518.     virtual void flush( DeleteType dt = DefDelete )
  519.         {
  520.         BI_OStackAsList::flush( dt );
  521.         }
  522.  
  523.     virtual ContainerIterator _FAR & initIterator() const;
  524.  
  525.     virtual classType isA() const
  526.         {
  527.         return stackClass;
  528.         }
  529.  
  530.     virtual _TCHAR _FAR * nameOf() const
  531.         {
  532.         return "BI_TCStackAsList";
  533.         }
  534.  
  535.     virtual void forEach( iterFuncType f, void _FAR *args )
  536.         {
  537.         BI_OStackAsList::forEach( f, args );
  538.         }
  539.  
  540.     virtual Object _FAR & firstThat( condFuncType f, void _FAR *args ) const
  541.         {
  542.         return ptrToRef(BI_OStackAsList::firstThat( f, args ));
  543.         }
  544.  
  545.     virtual Object _FAR & lastThat( condFuncType f, void _FAR *args ) const
  546.         {
  547.         return ptrToRef(BI_OStackAsList::lastThat( f, args ));
  548.         }
  549.  
  550. };
  551.  
  552. class _CLASSTYPE BI_TCStackAsListIterator : public ContainerIterator
  553. {
  554.  
  555. public:
  556.  
  557.     BI_TCStackAsListIterator( const BI_TCStackAsList _FAR & s ) :
  558.         iter((const BI_OStackAsList&)s)
  559.         {
  560.         }
  561.  
  562.     virtual operator int()
  563.         {
  564.         return int(iter);
  565.         }
  566.  
  567.     virtual Object _FAR & current()
  568.         {
  569.         return Object::ptrToRef(iter.current());
  570.         }
  571.  
  572.     virtual Object _FAR & operator ++ ( int )
  573.         {
  574.         return Object::ptrToRef(iter++);
  575.         }
  576.  
  577.     virtual Object _FAR & operator ++ ()
  578.         {
  579.         return Object::ptrToRef(++iter);
  580.         }
  581.  
  582.     virtual void restart()
  583.         {
  584.         iter.restart();
  585.         }
  586.  
  587. private:
  588.  
  589.     BI_OStackAsListIterator iter;
  590.  
  591. };
  592.  
  593. inline ContainerIterator _FAR & BI_TCStackAsList::initIterator() const
  594. {
  595.     return *new BI_TCStackAsListIterator( *this );
  596. }
  597.  
  598. #endif  // TEMPLATES
  599.  
  600. #if defined( __BCOPT__ ) && !defined( __FLAT__ ) && !defined( _ALLOW_po )
  601. #pragma option -po.
  602. #endif
  603. #pragma option -Vo.
  604.  
  605. #endif  // __STACK_H
  606.  
  607.